A new framework for strictness analysis using abstract demand propagation

This paper presents a novel approach to strictness analysis called abstract demand propagation, approach developed for the implementation of lazy functional programming languages on parallel machines. Although some work on strictness analysis using demand propagation has been done before, the present work is original in that it gives a precise interpretation of the notions of demands and demand propagation using an exact non-standard denotational semantics. The intuition behind this semantics is that it represents a form of inverse computation, i.e., it determines the least amount of information needed to produce at least some required (demanded) result. Viewing demand propagation as a form of inverse computation allows to establish the soundness of our non-standard semantics by formally relating it with the standard semantics. In order to deene a compile-time analysis based on demand propagation, safety and termination must be ensured. This is done by deening an abstract interpretation of the exact non-standard demand propagation semantics, thus providing an abstract demand propagation semantics. This abstraction makes it possible to express various generalized strictness properties: deenite non-termination, argument not needed, various levels of strictness for data structures, including the important property of head-strictness, etc. Furthermore, the safety of this abstraction can also be established through the notion of inverse, because any superset of an inverse can easily be shown to also be an inverse. Our abstract demand propagation approach has been incorporated into a prototype compiler for a lazy variant of (a subset of) the Id functional programming language targeted for a ne-grain dataaow machine. Abstract demand propagation provided a naturally parallel framework for the implementation of a lazy language. It also made possible the incorporation of a number of additional features: function specialization, abstract conditions, run-time demands. This compiler is brieey described, together with some of the additional features it incorporates. A brief overview of the results from experiments performed with the compiler are also presented, experiments whose goal was to determine the impact of laziness on parallelism. 1 Introduction One of the major motivation for functional programming languages is as an alternative programming paradigm, especially for programming parallel machines Bac78, Hud89]. Functional programs are naturally parallel | the parallelism is implicit, based on the data dependencies | and determi-nate | any order of evaluation always produces the same result. As is well-known, the implementation of lazy languages requires much overhead Hen80]. Fortunately, it is often possible to avoid part of this …